home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / CUGUK / UTIL_SRC / C126.ZIP / LEX.ZIP / OUT1.C < prev    next >
Text File  |  1990-01-19  |  11KB  |  326 lines
  1. /*  out1.c
  2.  *
  3.  * Copyright (c) 1978 Charles H. Forsyth
  4.  *
  5.  * Modified 02-Dec-80 Bob Denny -- Conditionalize debug code for smaller size
  6.  *                           01 -- Removed ending() function code from here
  7.  *                                  to lex.c, so ytab.c code could share the
  8.  *                                  same overlay region as this module.
  9.  *                           02 -- Removed nfaprint(), llactr(), newcase(),
  10.  *                                  cclprint(), chprint() and setline(),
  11.  *                                  the rest of this can share an overlay.
  12.  *                                  They're in 'out2.c'. This is now 'out1.c'.
  13.  *          29-May-81 Bob Denny -- More extern hacking for RSX overlaying.
  14.  *          19-Mar-82 Bob Denny -- New compiler and library
  15.  *          03-May-82 Bob Denny -- Final touches, remove unreferenced autos
  16.  *          28-Aug-82 Bob Denny -- Put "=" into table initializers to make
  17.  *                                  new compiler happy. Add "-s" code to
  18.  *                                  supress "#include <stdio.h>" in output.
  19.  *                                  Tables output 8 values/line instead of
  20.  *                                  16.  Overran R.H. edge on 3 digit octals.
  21.  *                                  Change output format for readability.
  22.  *          31-Aug-82 Bob Denny -- Add lexswitch( ...) to llstin so table
  23.  *                                  name selected by -t switch is automatically
  24.  *                                  switched-to at yylex() startup time.  Removed
  25.  *                                  hard reference to "lextab" from yylex();
  26.  *                                  This module generates extern declaration
  27.  *                                  for forward reference.
  28.  *          14-Apr-83 Bob Denny -- Add VAX11C support.  Remove usage of remote
  29.  *                                  formats (damn!) not supported on VAX-11 C.
  30.  *                                 Use "short int" for 16-bit table items under
  31.  *                                  VAX-11 C to save size.
  32.  *                                 Contitional out flaky debug code.  Probably
  33.  *                                  related to non-functional minimization.
  34.  *                      20-Nov-83 Scott Guthery -- Adapt for IBM PC & DeSmet C
  35.  *                      26-Dec-83 Scott Guthery -- Removed "extern FILE lexin" from llstin
  36.  *                                                                         code and put it lex.h.
  37.  */
  38.  
  39. /*
  40.  * lex -- output human- and machine-readable tables
  41.  */
  42. #include <stdio.h>
  43. #include <string.h>
  44. #include "lexlex.h"
  45. #include "lh.h"
  46.  
  47. extern char * ignore;
  48. extern char * illeg;
  49. extern char * breakc;
  50. extern int nlook;
  51.  
  52. char strdec1 [] = "\nstruct lextab %s =\t{\n";
  53. char strdec2 [] = "\t\t\t%d,\t\t/* Highest state */\n";
  54. char strdec3 [] = "\t\t\t_D%s\t/* --> \"Default state\" table */\n";
  55. char strdec4 [] = "\t\t\t_N%s\t/* --> \"Next state\" table */\n";
  56. char strdec5 [] = "\t\t\t_C%s\t/* --> \"Check value\" table */\n";
  57. char strdec6 [] = "\t\t\t_B%s\t/* --> \"Base\" table */\n";
  58. char strdec7 [] = "\t\t\t%d,\t\t/* Index of last entry in \"next\" */\n";
  59. char strdec8 [] = "\t\t\t%s,\t\t/* --> Byte-int move routine */\n";
  60. char strdec9 [] = "\t\t\t_F%s\t/* --> \"Final state\" table */\n";
  61. char strdec10 [] = "\t\t\t_A%s\t/* --> Action routine */\n";
  62. char strdec11 [] = "\n\t\t\t%s%s\t/* Look-ahead vector */\n";
  63.  
  64. char ptabnam [] =
  65. { "         "
  66. }
  67. ;
  68.  
  69. /*
  70.  * Print the minimised DFA, and at the same time, construct the vector which
  71.  * indicates final states by associating them with their translation index.
  72.  * (DFA printout supressed ifndef DEBUG.)
  73.  */
  74. void dfaprint ()
  75. { register struct move * dp;
  76.   register struct dfa * st;
  77.   register int i;
  78.   int fi ,
  79.      k,
  80.      l;
  81.   vstart ( "LL16BIT _F%s", tabname );
  82. #ifdef DEBUG
  83.     fprintf ( lexlog, "\nMinimised DFA for complete syntax\n" );
  84. #endif
  85.   for ( i = 0; i < ndfa; i ++ )
  86.     {
  87. #ifdef DEBUG
  88.         fprintf ( lexlog, "\nstate %d", i );
  89. #endif
  90.       st =& dfa [ i ];
  91.       k =- 1;
  92.       if ( fi = st -> df_name -> s_final )
  93.         { k = nfa [ fi ]. n_trans - trans;
  94. #ifdef DEBUG
  95.             fprintf ( lexlog, " (final %d[%d])", fi, k );
  96. #endif
  97.           if ( nfa [ fi ]. n_flag & FLOOK )
  98.             { k |= ( nfa [ fi ]. n_look + 1 ) << 11;
  99. #ifdef DEBUG
  100.                 fprintf ( lexlog, " restore %d", nfa [ fi ]. n_look );
  101. #endif
  102.             }
  103.         }
  104.       if ( l = st -> df_name -> s_look )
  105. #ifdef DEBUG
  106.           fprintf ( lexlog, " look-ahead %o", l );
  107. #else
  108.         ;
  109. #endif
  110.       vel ( " %d,", k );
  111. #ifdef MINIM_OK
  112.         k = st -> df_name -> s_group -> s_els [ 0 ];
  113.         if ( k != i )
  114.           { fprintf ( lexlog, " deleted\n" );
  115.             continue;
  116.           }
  117.         fprintf ( lexlog, "\n" );
  118.         for ( dp = st -> df_base; dp < st -> df_max; dp = range ( st, dp ))
  119.           if ( st -> df_default )
  120.             fprintf ( lexlog, "\t.\tsame as %d\n", st -> df_default - dfa );
  121. #endif
  122.     }
  123.   vel ( " %d,", - 1 );                  /* blocking state */
  124.   vend ();
  125. }
  126.  
  127. #ifdef MINIM_OK
  128.  
  129.   range ( st, dp )register struct dfa * st;
  130.   register struct move * dp;
  131.   { int low ,
  132.        high,
  133.        last;
  134.     struct set * s;
  135.     register int a;
  136.     while ( dp < st -> df_max && dp -> m_check != st )
  137.       dp ++ ;
  138. /* * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ****
  139.  * This always returns given the above statement ! *
  140.  * * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * **
  141.  */
  142.     if ( dp >= st -> df_max )
  143.       return ( dp );
  144.     low = dp - st -> df_base;
  145.     s = dp -> m_next;
  146.     for ( last = low - 1; dp < st -> df_max &&
  147.           dp -> m_check == st &&
  148.           ( a = dp - st -> df_base ) == last + 1 &&
  149.             dp -> m_next == s; dp ++ )
  150.       last = a;
  151.     high = last;
  152.     fprintf ( lexlog, "\t" );
  153.     if ( high == low )
  154.       chprint ( low );
  155.     else
  156.       {
  157.         fprintf ( lexlog, "[" );
  158.         if ( high - low > 4 )
  159.           { chprint ( low );
  160.             fprintf ( lexlog, "-" );
  161.             chprint ( high );
  162.           }
  163.         else
  164.           {
  165.             while ( low <= high )
  166.               chprint ( low ++ );
  167.           }
  168.         fprintf ( lexlog, "]" );
  169.       }
  170.     if ( s -> s_state == NULL )
  171.       fprintf ( lexlog, "\tNULL\n" );
  172.     else
  173.       fprintf ( lexlog, "\t%d\n", s -> s_state - dfa );
  174.     return ( dp );
  175.   }
  176. #endif
  177.  
  178. void heading ()
  179. { char * ver;
  180.   fprintf ( llout, "\/\*\n * Created by IBM PC LEX from file \"%s\"\n", infile );
  181.   if ( sflag == 0 )                     /* If "standalone" switch off */
  182.     { fprintf ( llout, " *\t- for use with standard I/O\n */\n" );
  183.       fprintf ( llout, "\n#include <stdio.h>\n" );
  184.     }
  185.   else
  186.     fprintf ( llout, " *\t- for use with stand-alone I/O\n */\n" );
  187.   fprintf ( llout, "#include \"lex.h\"\n" );
  188.   fprintf ( llout, "#define LL16BIT int\n" );
  189.   fprintf ( llout, "extern int _lmov%c();\n", ( ndfa <= 255 ) ? 'b' : 'i' );
  190.   fprintf ( llout, "extern struct lextab *_tabp;\n" );
  191.   fprintf ( llout, "extern int  yyline;\n" );
  192.   fprintf ( llout, "extern char *llend;\n" );
  193.   fprintf ( llout, "int lexval;\n" );
  194. /*  fprintf ( llout, "char lbuf[];\n" ); --jk-- */
  195. }
  196.  
  197. void dfawrite ()
  198. { register struct move * dp;
  199.   register int i,
  200.      a;
  201.   struct dfa * st, * def;
  202.   struct set * xp;
  203.   char * xcp;
  204.   setline ();
  205.   fprintf ( llout, "\n#define\tLLTYPE1\t%s\n", ndfa <= 255 ? "char" : "LL16BIT" );
  206.   vstart ( "LLTYPE1 _N%s", tabname );
  207.   for ( i = 0; i <= llnxtmax; i ++ )
  208.     if ( xp = move [ i ]. m_next )
  209.       vel ( " %d,", xp -> s_state - dfa );
  210.   else
  211.     vel ( " %d,", ndfa );
  212.   vend ();
  213.   vstart ( "LLTYPE1 _C%s", tabname );
  214.   for ( i = 0; i <= llnxtmax; i ++ )
  215.     if ( st = move [ i ]. m_check )
  216.       vel ( " %d,", st - dfa );
  217.   else
  218.     vel ( " %d,", - 1 );
  219.   vend ();
  220.   vstart ( "LLTYPE1 _D%s", tabname );
  221.   for ( i = 0; i < ndfa; i ++ )
  222.     if ( def = dfa [ i ]. df_default )
  223.       vel ( " %d,", def - dfa );
  224.   else
  225.     vel ( " %d,", ndfa );               /* refer to blocking state */
  226.   vend ();
  227.   vstart ( "LL16BIT _B%s", tabname );
  228.   for ( i = 0; i < ndfa; i ++ )
  229.     if ( dp = dfa [ i ]. df_base )
  230.       vel ( " %d,", dp - move );
  231.   else
  232.     vel ( " %d,", 0 );
  233.   vel ( " %d,", 0 );                    /* for blocking state */
  234.   vend ();
  235.   if ( nlook )
  236.     { fprintf ( llout, "char    *llsave[%d];\n", nlook );
  237.       vstart ( "LL16BIT _L%s", tabname );
  238.       a = nlook <= NBPC ? NCHARS - 1 : - 1;
  239.       for ( i = 0; i < ndfa; i ++ )
  240.         vel ( " 0%o,", dfa [ i ]. df_name -> s_look & a );
  241.       vel ( " %d,", 0 );
  242.       vend ();
  243.     }
  244.   dospccl ( ignore, "LLIGN", "X" );
  245.   dospccl ( breakc, "LLBRK", "Y" );
  246.   dospccl ( illeg, "LLILL", "Z" );
  247.   strcpy ( ptabnam, tabname );
  248.   strcat ( ptabnam, "," );
  249.   fprintf ( llout, strdec1, tabname );
  250.   fprintf ( llout, strdec2, ndfa );
  251.   fprintf ( llout, strdec3, ptabnam );
  252.   fprintf ( llout, strdec4, ptabnam );
  253.   fprintf ( llout, strdec5, ptabnam );
  254.   fprintf ( llout, strdec6, ptabnam );
  255.   fprintf ( llout, strdec7, llnxtmax );
  256.   fprintf ( llout, strdec8, ndfa <= 255 ? "_lmovb" : "_lmovi" );
  257.   fprintf ( llout, strdec9, ptabnam );
  258.   fprintf ( llout, strdec10, ptabnam );
  259.   fprintf ( llout, strdec11, nlook ? "_L" : "", nlook ? ptabnam : "NULL,   " );
  260.   refccl ( ignore, "Ignore", "X" );
  261.   refccl ( breakc, "Break", "Y" );
  262.   refccl ( illeg, "Illegal", "Z" );
  263.   fprintf ( llout, "\t\t\t};\n" );
  264.   if ( sflag == 0 )                     /* If stdio flavor */
  265.     { fprintf ( llout, "\n/* Standard I/O selected */\n" );
  266.       fprintf ( llout, "FILE *lexin;\n\n" );
  267.       fprintf ( llout, "void llstin()\n   {\n   if(lexin == NULL)\n" );
  268.       fprintf ( llout, "      lexin = stdin;\n" );
  269.     }
  270.   else                                  /* Stand-alone flavor */
  271.     {
  272.       fprintf ( llout, "\n/* Stand-alone selected */\n" );
  273.       fprintf ( llout, "\llstin()\n   {\n" );
  274.     }
  275.   fprintf ( llout, "   if(_tabp == NULL)\n" );
  276.   fprintf ( llout, "      lexswitch(&%s);\n   }\n\n", tabname );
  277. }
  278.  
  279. void dospccl ( cp, s, tag )register char * cp;
  280. char * s,
  281.      * tag;
  282. { register int n;
  283.   char cclnam [ 16 ];
  284.   if ( cp == 0 )
  285.     return;
  286.   fprintf ( llout, "#define\t%s\t%s\n", s, tag );
  287.   strcpy ( cclnam, tag );
  288.   strcat ( cclnam, tabname );
  289.   vstart ( "char _%s", cclnam );
  290.   for ( n = sizeof ( ccls [ 0 ]); n -- ; )
  291.     vel ( " 0%o,", * cp ++ & 0377 );
  292.   vend ();
  293. }
  294.  
  295. void refccl ( cp, nm, tag )char * cp,
  296.      * nm,
  297.      * tag;
  298. { if ( cp == 0 )
  299.     fprintf ( llout, "\t\t\t0,\t\t/* No %s class */\n", nm );
  300.   else
  301.     fprintf ( llout, "\t_%s%s,\t/* %s class */\n", tag, tabname, nm );
  302. }
  303.  
  304. int vnl ;
  305.  
  306. void vstart ( fmt, str )char * fmt;
  307. char * str;                             /* * WATCH IT * */
  308. { vnl = 0;
  309.   putc ( '\n', llout );
  310.   fprintf ( llout, fmt, str );
  311.   fprintf ( llout, "[] =\n   {\n  " );
  312. }
  313.  
  314. void vend ()
  315. { fprintf ( llout, "\n   };\n" );
  316. }
  317.  
  318. void vel ( fmt, val )char * fmt;
  319. int val ;                               /* * WATCH IT * */
  320. { fprintf ( llout, fmt, val );
  321.   if (( ++ vnl & 07 ) == 0 )
  322.     fprintf ( llout, "\n  " );
  323. }
  324.  
  325. /* end of out1.c */
  326.